var express = require("express");
var router = express.Router();
var {
  pcusermodel,
  permissionModel,
  roleModel,
  userRoleModel,
} = require("../db/jjx"); // 引用数据库
var jwt = require("jsonwebtoken");
var mongoose = require("mongoose");

// JWT 密钥
const JWT_SECRET = "your-secret-key-2024"; // 在生产环境中应该使用环境变量

// 引入密码安全工具
const passwordSecurity = require("../utils/passwordSecurity");

// ==================== 工具函数 ====================

// 统一成功响应格式
const sendSuccess = (res, data, message = "操作成功") => {
  res.json({
    success: true,
    message,
    data,
  });
};

// 统一错误处理
const handleError = (error, res, message = "服务器内部错误") => {
  console.error(message + ":", error);
  res.status(500).json({
    success: false,
    message,
  });
};

/* GET users listing. */
router.get("/", function (req, res, next) {
  res.send("respond with a resource");
});

// 用户注册接口
router.post("/register", async (req, res) => {
  try {
    const { username, password } = req.body;

    // 输入验证
    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: "用户名和密码不能为空",
      });
    }

    if (username.length < 3 || username.length > 20) {
      return res.status(400).json({
        success: false,
        message: "用户名长度必须在3-20个字符之间",
      });
    }

    // 检查用户是否已存在
    const existingUser = await pcusermodel.findOne({ username });
    if (existingUser) {
      return res.status(400).json({
        success: false,
        message: "用户名已存在",
      });
    }

    // 处理密码（支持加密和明文两种方式）
    let hashedPassword;
    try {
      // 尝试解密RSA加密的密码，然后进行bcrypt哈希
      hashedPassword = await passwordSecurity.processPasswordForStorage(
        password
      );
      console.log("✅ 使用RSA+bcrypt加密存储密码");
    } catch (decryptError) {
      // 如果解密失败，假设是明文密码（兼容旧版本），直接进行bcrypt哈希
      console.log("⚠️ 密码未加密传输，使用明文进行bcrypt哈希");

      // 明文密码长度验证
      if (password.length < 6) {
        return res.status(400).json({
          success: false,
          message: "密码长度不能少于6位",
        });
      }

      hashedPassword = await passwordSecurity.hashPassword(password);
    }

    // 创建新用户，使用哈希密码
    const newUser = new pcusermodel({
      username,
      password: hashedPassword, // 存储哈希密码
    });

    await newUser.save();

    res.status(201).json({
      success: true,
      message: "注册成功",
      data: {
        userId: newUser._id,
        username: newUser.username,
      },
    });
  } catch (error) {
    console.error("注册错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 用户登录接口
router.post("/login", async (req, res) => {
  try {
    const { username, password } = req.body;
    console.log(
      `🔑 登录尝试 - 用户: ${username}, 密码长度: ${password?.length || 0}`
    );

    // 输入验证
    if (!username || !password) {
      return res.status(400).json({
        success: false,
        message: "用户名和密码不能为空",
      });
    }

    // 查找用户
    const user = await pcusermodel.findOne({ username });
    console.log(
      `👤 用户查找结果 - 找到用户: ${!!user}, 密码格式: ${
        user?.password?.startsWith("$2") ? "bcrypt哈希" : "明文"
      }`
    );

    if (!user) {
      console.log(`❌ 用户 ${username} 不存在`);
      return res.status(401).json({
        success: false,
        message: "用户名或密码错误",
      });
    }

    // 验证密码（支持新旧两种方式）
    let isValidPassword = false;

    // 首先尝试RSA解密来判断是否为加密密码
    let isEncryptedPassword = false;
    try {
      passwordSecurity.decryptPassword(password);
      isEncryptedPassword = true;
      console.log("🔐 检测到RSA加密密码");
    } catch (error) {
      isEncryptedPassword = false;
      console.log("📝 检测到明文密码");
    }

    if (isEncryptedPassword) {
      // RSA加密密码验证
      try {
        isValidPassword = await passwordSecurity.verifyEncryptedPassword(
          password,
          user.password
        );
        console.log("✅ 使用RSA+bcrypt验证密码");
      } catch (error) {
        console.log("❌ RSA加密密码验证失败:", error.message);
        isValidPassword = false;
      }
    } else {
      // 明文密码验证（兼容性处理）
      if (user.password && user.password.startsWith("$2")) {
        // 如果存储的是bcrypt哈希，直接验证明文密码
        isValidPassword = await passwordSecurity.verifyPassword(
          password,
          user.password
        );
        console.log("✅ 使用bcrypt验证明文传输密码");
      } else {
        // 如果存储的是明文密码，直接对比（向后兼容）
        isValidPassword = password === user.password;
        console.log("⚠️ 使用明文密码验证（需要迁移）");
      }
    }

    if (!isValidPassword) {
      console.log(`❌ 密码验证失败 - 用户: ${username}`);
      return res.status(401).json({
        success: false,
        message: "用户名或密码错误",
      });
    }

    console.log(`✅ 登录成功 - 用户: ${username}`);

    // 优化：分步查询，减少嵌套populate的复杂度
    const userRoles = await userRoleModel
      .find({ userId: user._id })
      .populate("roleId");

    if (userRoles.length === 0) {
      // 如果用户没有角色，返回空权限
      const accessToken = jwt.sign(
        { userId: user._id, username: user.username, type: "access" },
        JWT_SECRET,
        { expiresIn: "15m" }
      );
      const refreshToken = jwt.sign(
        { userId: user._id, username: user.username, type: "refresh" },
        JWT_SECRET,
        { expiresIn: "7d" }
      );

      return res.json({
        success: true,
        message: "登录成功",
        data: {
          userId: user._id,
          username: user.username,
          roles: [],
          permissions: [],
          accessToken: accessToken,
          refreshToken: refreshToken,
        },
      });
    }

    // 提取角色信息
    const roles = userRoles.map((userRole) => ({
      id: userRole.roleId._id,
      name: userRole.roleId.name,
      code: userRole.roleId.code,
    }));

    // 获取所有角色的权限ID
    const roleIds = userRoles.map((ur) => ur.roleId._id);
    const rolesWithPermissions = await roleModel
      .find({ _id: { $in: roleIds } })
      .populate("permissions");

    // 合并权限（只返回权限代码，减少数据传输）
    const permissionSet = new Set();
    const permissions = [];

    rolesWithPermissions.forEach((role) => {
      if (role.permissions) {
        role.permissions.forEach((permission) => {
          if (!permissionSet.has(permission.code)) {
            permissionSet.add(permission.code);
            permissions.push({
              id: permission._id,
              name: permission.name,
              code: permission.code,
              module: permission.module,
              type: permission.type,
            });
          }
        });
      }
    });

    // 生成 Access Token (短期，15分钟)
    const accessToken = jwt.sign(
      {
        userId: user._id,
        username: user.username,
        type: "access",
      },
      JWT_SECRET,
      { expiresIn: 15 * 60 }
    );

    // 生成 Refresh Token (长期，7天)
    const refreshToken = jwt.sign(
      {
        userId: user._id,
        username: user.username,
        type: "refresh",
      },
      JWT_SECRET,
      { expiresIn: 7 * 24 * 60 * 60 }
    );

    res.json({
      success: true,
      message: "登录成功",
      data: {
        userId: user._id,
        username: user.username,
        roles: roles,
        permissions: permissions,
        accessToken: accessToken,
        refreshToken: refreshToken,
      },
    });
  } catch (error) {
    console.error("登录错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 刷新token接口
router.post("/refresh-token", async (req, res) => {
  try {
    const { refreshToken } = req.body;

    if (!refreshToken) {
      return res.status(401).json({
        success: false,
        message: "Refresh token缺失",
      });
    }

    // 验证refresh token
    const decoded = jwt.verify(refreshToken, JWT_SECRET);

    // 检查token类型
    if (decoded.type !== "refresh") {
      return res.status(401).json({
        success: false,
        message: "无效的refresh token",
      });
    }

    // 查找用户（确保用户仍然存在）
    const user = await pcusermodel.findById(decoded.userId);
    if (!user) {
      return res.status(401).json({
        success: false,
        message: "用户不存在",
      });
    }

    // 生成新的access token
    const newAccessToken = jwt.sign(
      {
        userId: user._id,
        username: user.username,
        type: "access",
      },
      JWT_SECRET,
      { expiresIn: "15m" }
    );

    // 可选：生成新的refresh token（滚动refresh token策略）
    const newRefreshToken = jwt.sign(
      {
        userId: user._id,
        username: user.username,
        type: "refresh",
      },
      JWT_SECRET,
      { expiresIn: "7d" }
    );

    res.json({
      success: true,
      message: "Token刷新成功",
      data: {
        accessToken: newAccessToken,
        refreshToken: newRefreshToken,
      },
    });
  } catch (error) {
    console.error("刷新token错误:", error);
    res.status(401).json({
      success: false,
      message: "Refresh token已过期或无效",
    });
  }
});

// 获取当前用户信息
router.get("/user/current", async (req, res) => {
  try {
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith("Bearer ")) {
      return res.status(401).json({
        success: false,
        message: "未提供有效的token",
      });
    }

    const token = authHeader.split(" ")[1];
    const decoded = jwt.verify(token, JWT_SECRET);

    // 获取用户信息
    const user = await pcusermodel.findById(decoded.userId, { password: 0 });
    if (!user) {
      return res.status(404).json({
        success: false,
        message: "用户不存在",
      });
    }

    res.json({
      success: true,
      message: "获取用户信息成功",
      data: user,
    });
  } catch (error) {
    console.error("获取用户信息错误:", error);
    res.status(401).json({
      success: false,
      message: "Token无效或已过期",
    });
  }
});

// 获取所有用户列表（包含角色信息）
router.get("/users", async (req, res) => {
  try {
    // 获取所有用户，但不返回密码字段，只选择必要字段
    const users = await pcusermodel
      .find({}, { username: 1, _id: 1, createdAt: 1, updatedAt: 1 })
      .sort({ _id: 1 })
      .lean(); // 使用lean()提高查询性能

    // 批量获取所有用户的角色信息
    const userIds = users.map((user) => user._id);
    const userRolesMap = new Map();

    if (userIds.length > 0) {
      const allUserRoles = await userRoleModel
        .find({ userId: { $in: userIds } })
        .populate("roleId");

      // 按用户ID分组角色
      allUserRoles.forEach((userRole) => {
        if (!userRolesMap.has(userRole.userId.toString())) {
          userRolesMap.set(userRole.userId.toString(), []);
        }
        if (userRole.roleId) {
          userRolesMap.get(userRole.userId.toString()).push({
            id: userRole.roleId._id,
            name: userRole.roleId.name,
            code: userRole.roleId.code,
          });
        }
      });
    }

    // 组合用户数据和角色数据
    const usersWithRoles = users.map((user) => ({
      ...user, // 已经是lean对象，不需要toObject()
      roles: userRolesMap.get(user._id.toString()) || [],
      permissionCount: userRolesMap.get(user._id.toString())?.length || 0,
      lastLoginAt: null,
    }));

    sendSuccess(res, usersWithRoles, "获取用户列表成功");
  } catch (error) {
    handleError(error, res, "获取用户列表错误");
  }
});

// ==================== 权限管理 ====================

// 获取所有权限列表
router.get("/permissions", async (req, res) => {
  try {
    const permissions = await permissionModel
      .find()
      .sort({ module: 1, createdAt: 1 });
    res.json({
      success: true,
      message: "获取权限列表成功",
      data: permissions,
    });
  } catch (error) {
    console.error("获取权限列表错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 创建权限
router.post("/permissions", async (req, res) => {
  try {
    const { name, code, description, module, type } = req.body;

    if (!name || !code || !module) {
      return res.status(400).json({
        success: false,
        message: "权限名称、权限编码和所属模块不能为空",
      });
    }

    const permission = new permissionModel({
      name,
      code,
      description,
      module,
      type,
    });

    await permission.save();

    res.status(201).json({
      success: true,
      message: "创建权限成功",
      data: permission,
    });
  } catch (error) {
    if (error.code === 11000) {
      res.status(400).json({
        success: false,
        message: "权限名称或编码已存在",
      });
    } else {
      console.error("创建权限错误:", error);
      res.status(500).json({
        success: false,
        message: "服务器内部错误",
      });
    }
  }
});

// 更新权限
router.put("/permissions/:id", async (req, res) => {
  try {
    const { id } = req.params;
    const { name, code, description, module, type, status } = req.body;

    const permission = await permissionModel.findByIdAndUpdate(
      id,
      { name, code, description, module, type, status },
      { new: true }
    );

    if (!permission) {
      return res.status(404).json({
        success: false,
        message: "权限不存在",
      });
    }

    res.json({
      success: true,
      message: "更新权限成功",
      data: permission,
    });
  } catch (error) {
    console.error("更新权限错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 删除权限
router.delete("/permissions/:id", async (req, res) => {
  try {
    const { id } = req.params;

    const permission = await permissionModel.findByIdAndDelete(id);

    if (!permission) {
      return res.status(404).json({
        success: false,
        message: "权限不存在",
      });
    }

    res.json({
      success: true,
      message: "删除权限成功",
    });
  } catch (error) {
    console.error("删除权限错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// ==================== 角色管理 ====================

// 获取所有角色列表
router.get("/roles", async (req, res) => {
  try {
    const roles = await roleModel
      .find()
      .populate("permissions")
      .sort({ createdAt: 1 });
    res.json({
      success: true,
      message: "获取角色列表成功",
      data: roles,
    });
  } catch (error) {
    console.error("获取角色列表错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 创建角色
router.post("/roles", async (req, res) => {
  try {
    const { name, code, description, permissions } = req.body;

    if (!name || !code) {
      return res.status(400).json({
        success: false,
        message: "角色名称和角色编码不能为空",
      });
    }

    const role = new roleModel({
      name,
      code,
      description,
      permissions: permissions || [],
    });

    await role.save();
    await role.populate("permissions");

    res.status(201).json({
      success: true,
      message: "创建角色成功",
      data: role,
    });
  } catch (error) {
    if (error.code === 11000) {
      res.status(400).json({
        success: false,
        message: "角色名称或编码已存在",
      });
    } else {
      console.error("创建角色错误:", error);
      res.status(500).json({
        success: false,
        message: "服务器内部错误",
      });
    }
  }
});

// 更新角色
router.put("/roles/:id", async (req, res) => {
  try {
    const { id } = req.params;
    const { name, code, description, permissions, status } = req.body;

    const role = await roleModel
      .findByIdAndUpdate(
        id,
        { name, code, description, permissions, status },
        { new: true }
      )
      .populate("permissions");

    if (!role) {
      return res.status(404).json({
        success: false,
        message: "角色不存在",
      });
    }

    res.json({
      success: true,
      message: "更新角色成功",
      data: role,
    });
  } catch (error) {
    console.error("更新角色错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 删除角色
router.delete("/roles/:id", async (req, res) => {
  try {
    const { id } = req.params;

    // 检查是否有用户使用此角色
    const userRoleCount = await userRoleModel.countDocuments({ roleId: id });
    if (userRoleCount > 0) {
      return res.status(400).json({
        success: false,
        message: "该角色正在被用户使用，无法删除",
      });
    }

    const role = await roleModel.findByIdAndDelete(id);

    if (!role) {
      return res.status(404).json({
        success: false,
        message: "角色不存在",
      });
    }

    res.json({
      success: true,
      message: "删除角色成功",
    });
  } catch (error) {
    console.error("删除角色错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// ==================== 用户角色管理 ====================

// 获取用户的角色
router.get("/users/:userId/roles", async (req, res) => {
  try {
    const { userId } = req.params;

    // 参数验证
    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({
        success: false,
        message: "无效的用户ID",
      });
    }

    const userRoles = await userRoleModel.find({ userId }).populate("roleId");
    const roles = userRoles.map((ur) => ur.roleId).filter((role) => role); // 过滤空值

    res.json({
      success: true,
      message: "获取用户角色成功",
      data: roles,
    });
  } catch (error) {
    console.error("获取用户角色错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 为用户分配角色
router.post("/users/:userId/roles", async (req, res) => {
  try {
    const { userId } = req.params;
    const { roleIds } = req.body;

    // 先删除用户现有的所有角色
    await userRoleModel.deleteMany({ userId });

    // 为用户分配新的角色
    const userRoles = roleIds.map((roleId) => ({
      userId,
      roleId,
    }));

    if (userRoles.length > 0) {
      await userRoleModel.insertMany(userRoles);
    }

    res.json({
      success: true,
      message: "分配用户角色成功",
    });
  } catch (error) {
    console.error("分配用户角色错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

// 获取用户的所有权限（优化版本）
router.get("/users/:userId/permissions", async (req, res) => {
  try {
    const { userId } = req.params;

    // 参数验证
    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({
        success: false,
        message: "无效的用户ID",
      });
    }

    // 优化：分步查询，避免深度嵌套
    const userRoles = await userRoleModel.find({ userId }).populate("roleId");

    if (userRoles.length === 0) {
      return res.json({
        success: true,
        message: "获取用户权限成功",
        data: [],
      });
    }

    // 获取所有角色的权限
    const roleIds = userRoles.map((ur) => ur.roleId._id);
    const rolesWithPermissions = await roleModel
      .find({ _id: { $in: roleIds } })
      .populate("permissions");

    // 合并权限（减少数据传输）
    const permissionSet = new Set();
    const permissions = [];

    rolesWithPermissions.forEach((role) => {
      if (role.permissions) {
        role.permissions.forEach((permission) => {
          if (!permissionSet.has(permission._id.toString())) {
            permissionSet.add(permission._id.toString());
            permissions.push({
              id: permission._id,
              name: permission.name,
              code: permission.code,
              module: permission.module,
              type: permission.type,
            });
          }
        });
      }
    });

    res.json({
      success: true,
      message: "获取用户权限成功",
      data: permissions,
    });
  } catch (error) {
    console.error("获取用户权限错误:", error);
    res.status(500).json({
      success: false,
      message: "服务器内部错误",
    });
  }
});

module.exports = router;
